I noticed a few things:

1. we can save the fiber stacks directly on Fiber instead of storing each into a different global Hash;
2. we can safely iterate fibers using Fiber.each (thread safe linked list);
3. bonus: we don't need to monkey patch Fiber.inactive anymore;
4. bonus: we don't need track_fiber to be a macro anymore (renamed caller_stack);
5. bonus: we can list the main fiber of threads, their spawn stack is empty (it could be the stack that led to start the thread) but their yield stack can be interesting.

The above allows us to not need an explicit lock anymore: we're always setting the stack for the current fiber, and we can have a few checks to make sure we can use said stack from another thread.

Which leads me to the last point: we can generate a backtrace from a Slice(Void*) directly (with a few changes) and we can store stacks as Slice(Void*) directly instead of Array(Void*).

The stacks slice is a struct and if its size won't change, then only the pointer will, so we wouldn't need thread synchronization... except for one caveat: the size can change from 0 to N (see comments) so we check for null pointer and size == 0 (to be resilient to any parallel write reorder), before deciding to use the stack.

I'm having some second thoughts about that. Maybe an Array would be safer: we'd merely update a pointer in place 🤔

I still save the stack as Array(Void*) then expose views into the array as Slice(Void*). The underlying buffer size is either 0 or DEPTH + SKIP.